package com.gitee.wsl.struct.tree.sample.trie

//package io.vavr.collection

//import com.gitee.wsl.base.Objects
//import com.gitee.wsl.base.Objects.equals
//import com.gitee.wsl.base.Objects.hashCode
//import com.gitee.wsl.base.Tuple
//import com.gitee.wsl.base.Tuple2
//import com.gitee.wsl.struct.tree.sample.trie.HashArrayMappedTrieModule.EmptyNode
//
//
///**
// * An immutable [Hash array mapped trie (HAMT)](https://en.wikipedia.org/wiki/Hash_array_mapped_trie).
// *
// * @author Ruslan Sennov
// */
//internal interface HashArrayMappedTrie<K, V> : Iterable<Tuple2<K, V>> {
//    val isEmpty: Boolean
//
//    fun size(): Int
//
//    fun get(key: K): Option<V>
//
//    fun getOrElse(key: K, defaultValue: V): V
//
//    fun containsKey(key: K): Boolean
//
//    fun put(key: K, value: V): HashArrayMappedTrie<K, V>
//
//    fun remove(key: K): HashArrayMappedTrie<K, V>?
//
//    override fun iterator(): Iterator<Tuple2<K, V>>
//
//    /**
//     * Provide unboxed access to the keys in the trie.
//     */
//    fun keysIterator(): Iterator<K>
//
//    /**
//     * Provide unboxed access to the values in the trie.
//     */
//    fun valuesIterator(): Iterator<V>
//
//    companion object {
//        const val serialVersionUID: Long = 1L
//
//        fun <K, V> empty(): HashArrayMappedTrie<K, V> {
//            return EmptyNode.instance()
//        }
//    }
//}
//
//internal interface HashArrayMappedTrieModule {
//    enum class Action {
//        PUT, REMOVE
//    }
//
//    class LeafNodeIterator<K, V> internal constructor(
//        root: AbstractNode<K, V>
//    ) :AbstractIterator<LeafNode<K, V>>() {
//        private val total: Int = root.size()
//        private val nodes = kotlin.arrayOfNulls<Any>(MAX_LEVELS)
//        private val indexes = IntArray(MAX_LEVELS)
//
//        private var level: Int
//        private var ptr = 0
//
//        init {
//            level = downstairs<K?, V?>(nodes, indexes, root, 0)
//        }
//
//        public override fun hasNext(): Boolean {
//            return ptr < total
//        }
//
//        protected val next: LeafNode<K, V>
//            get() {
//                var node = nodes[level]
//                while (node !is LeafNode<*, *>) {
//                    node = findNextLeaf()
//                }
//                ptr++
//                if (node is LeafList<*, *>) {
//                    val leaf = node as LeafList<K?, V?>
//                    nodes[level] = leaf.tail
//                    return leaf
//                } else {
//                    nodes[level] = EmptyNode.Companion.instance<Any?, Any?>()
//                    return node as LeafSingleton<K?, V?>
//                }
//            }
//
//        private fun findNextLeaf(): Any? {
//            var node: AbstractNode<K?, V?>? = null
//            while (level > 0) {
//                level--
//                indexes[level]++
//                node = getChild<K?, V?>(nodes[level] as AbstractNode<K?, V?>?, indexes[level])
//                if (node != null) {
//                    break
//                }
//            }
//            level = downstairs<K?, V?>(nodes, indexes, node, level + 1)
//            return nodes[level]
//        }
//
//        companion object {
//            // buckets levels + leaf level = (Integer.SIZE / AbstractNode.SIZE + 1) + 1
//            private val MAX_LEVELS: Int = Int.MAX_VALUE / AbstractNode.Companion.SIZE + 2
//
//            private fun <K, V> downstairs(
//                nodes: Array<Any?>,
//                indexes: IntArray,
//                root: AbstractNode<K?, V?>?,
//                level: Int,
//            ): Int {
//                var root = root
//                var level = level
//                while (true) {
//                    nodes[level] = root
//                    indexes[level] = 0
//                    root = getChild<K?, V?>(root, 0)
//                    if (root == null) {
//                        break
//                    } else {
//                        level++
//                    }
//                }
//                return level
//            }
//
//            private fun <K, V> getChild(node: AbstractNode<K?, V?>?, index: Int): AbstractNode<K?, V?>? {
//                if (node is IndexedNode<*, *>) {
//                    val subNodes = (node as IndexedNode<K?, V?>).subNodes
//                    return if (index < subNodes.size) subNodes[index] as AbstractNode<K?, V?>? else null
//                } else if (node is ArrayNode<*, *>) {
//                    val arrayNode = node as ArrayNode<K?, V?>
//                    return if (index < AbstractNode.Companion.BUCKET_SIZE) arrayNode.subNodes[index] as AbstractNode<K?, V?>? else null
//                }
//                return null
//            }
//        }
//    }
//
//    /**
//     * An abstract base class for nodes of a HAMT.
//     *
//     * @param <K> Key type
//     * @param <V> Value type
//    </V></K> */
//    class AbstractNode<K, V> : HashArrayMappedTrie<K, V> {
//        abstract fun lookup(shift: Int, keyHash: Int, key: K?): Option<V>
//
//        abstract fun lookup(shift: Int, keyHash: Int, key: K?, defaultValue: V?): V?
//
//        abstract fun modify(shift: Int, keyHash: Int, key: K?, value: V?, action: Action?): AbstractNode<K?, V?>
//
//        fun nodes(): Iterator<LeafNode<K?, V?>?> {
//            return HashArrayMappedTrieModule.LeafNodeIterator<K?, V?>(this)
//        }
//
//        override fun iterator(): Iterator<Tuple2<K?, V?>?> {
//            return nodes().map({ node -> Tuple.of(node.key(), node.value()) })
//        }
//
//        override fun keysIterator(): Iterator<K?> {
//            return nodes().map({ obj: LeafNode<*, *>? -> obj!!.key() })
//        }
//
//        override fun valuesIterator(): Iterator<V?> {
//            return nodes().map({ obj: LeafNode<*, *>? -> obj!!.value() })
//        }
//
//        override fun get(key: K?): Option<V?>? {
//            return lookup(0, hashCode(key), key)
//        }
//
//        override fun getOrElse(key: K?, defaultValue: V?): V? {
//            return lookup(0, hashCode(key), key, defaultValue)
//        }
//
//        override fun containsKey(key: K?): Boolean {
//            return get(key).isDefined()
//        }
//
//        override fun put(key: K?, value: V?): HashArrayMappedTrie<K?, V?> {
//            return modify(0, hashCode(key), key, value, PUT)
//        }
//
//        override fun remove(key: K?): HashArrayMappedTrie<K?, V?> {
//            return modify(0, hashCode(key), key, null, REMOVE)
//        }
//
//        override fun toString(): String {
//            return iterator().map({ t -> t._1 + " -> " + t._2 }).mkString("HashArrayMappedTrie(", ", ", ")")
//        }
//
//        companion object {
//            private const val serialVersionUID = 1L
//
//            const val SIZE: Int = 5
//            val BUCKET_SIZE: Int = 1 shl SIZE
//            val MAX_INDEX_NODE: Int = BUCKET_SIZE shr 1
//            val MIN_ARRAY_NODE: Int = BUCKET_SIZE shr 2
//
//            fun hashFragment(shift: Int, hash: Int): Int {
//                return (hash ushr shift) and (BUCKET_SIZE - 1)
//            }
//
//            fun toBitmap(hash: Int): Int {
//                return 1 shl hash
//            }
//
//            fun fromBitmap(bitmap: Int, bit: Int): Int {
//                return bitCount(bitmap and (bit - 1))
//            }
//
//            fun update(arr: Array<Any?>, index: Int, newElement: Any?): Array<Any?> {
//                val newArr: Array<Any?> = copyOf(arr, arr.size)
//                newArr[index] = newElement
//                return newArr
//            }
//
//            fun remove(arr: Array<Any?>, index: Int): Array<Any?> {
//                val newArr = kotlin.arrayOfNulls<Any>(arr.size - 1)
//                java.lang.System.arraycopy(arr, 0, newArr, 0, index)
//                java.lang.System.arraycopy(arr, index + 1, newArr, index, arr.size - index - 1)
//                return newArr
//            }
//
//            fun insert(arr: Array<Any?>, index: Int, newElem: Any?): Array<Any?> {
//                val newArr = kotlin.arrayOfNulls<Any>(arr.size + 1)
//                java.lang.System.arraycopy(arr, 0, newArr, 0, index)
//                newArr[index] = newElem
//                java.lang.System.arraycopy(arr, index, newArr, index + 1, arr.size - index)
//                return newArr
//            }
//        }
//    }
//
//    /**
//     * The empty node.
//     *
//     * @param <K> Key type
//     * @param <V> Value type
//    </V></K> */
//    class EmptyNode<K, V> private constructor() : AbstractNode<K?, V?>(), Serializable {
//        override fun lookup(shift: Int, keyHash: Int, key: K?): Option<V?> {
//            return Option.none()
//        }
//
//        override fun lookup(shift: Int, keyHash: Int, key: K?, defaultValue: V?): V? {
//            return defaultValue
//        }
//
//        override fun modify(shift: Int, keyHash: Int, key: K?, value: V?, action: Action?): AbstractNode<K?, V?> {
//            return if (action == REMOVE) this else LeafSingleton<K?, V?>(keyHash, key, value)
//        }
//
//        override fun isEmpty(): Boolean {
//            return true
//        }
//
//        override fun size(): Int {
//            return 0
//        }
//
//        public override fun nodes(): Iterator<LeafNode<K?, V?>?> {
//            return Iterator.empty()
//        }
//
//        /**
//         * Instance control for object serialization.
//         *
//         * @return The singleton instance of EmptyNode.
//         * @see Serializable
//         */
//        private fun readResolve(): Any {
//            return INSTANCE
//        }
//
//        companion object {
//            private const val serialVersionUID = 1L
//
//            private val INSTANCE: EmptyNode<*, *> = EmptyNode<Any?, Any?>()
//
//            fun <K, V> instance(): EmptyNode<K?, V?>? {
//                return INSTANCE as EmptyNode<K?, V?>?
//            }
//        }
//    }
//
//    /**
//     * Representation of a HAMT leaf.
//     *
//     * @param <K> Key type
//     * @param <V> Value type
//    </V></K> */
//    class LeafNode<K, V> : AbstractNode<K?, V?>() {
//        abstract fun key(): K?
//
//        abstract fun value(): V?
//
//        abstract fun hash(): Int
//
//        override fun isEmpty(): Boolean {
//            return false
//        }
//
//        companion object {
//            private const val serialVersionUID = 1L
//
//            fun <K, V> mergeLeaves(
//                shift: Int,
//                leaf1: LeafNode<K?, V?>,
//                leaf2: LeafSingleton<K?, V?>,
//            ): AbstractNode<K?, V?> {
//                val h1 = leaf1.hash()
//                val h2 = leaf2.hash()
//                if (h1 == h2) {
//                    return LeafList<K?, V?>(h1, leaf2.key(), leaf2.value(), leaf1)
//                }
//                val subH1 = hashFragment(shift, h1)
//                val subH2 = hashFragment(shift, h2)
//                val newBitmap = toBitmap(subH1) or toBitmap(subH2)
//                if (subH1 == subH2) {
//                    val newLeaves = mergeLeaves<K?, V?>(shift + SIZE, leaf1, leaf2)
//                    return HashArrayMappedTrieModule.IndexedNode<K?, V?>(
//                        newBitmap,
//                        newLeaves.size(),
//                        arrayOf<Any>(newLeaves)
//                    )
//                } else {
//                    return HashArrayMappedTrieModule.IndexedNode<K?, V?>(
//                        newBitmap, leaf1.size() + leaf2.size(),
//                        if (subH1 < subH2) arrayOf<Any>(leaf1, leaf2) else arrayOf<Any>(leaf2, leaf1)
//                    )
//                }
//            }
//        }
//    }
//
//    /**
//     * Representation of a HAMT leaf node with single element.
//     *
//     * @param <K> Key type
//     * @param <V> Value type
//    </V></K> */
//    class LeafSingleton<K, V> internal constructor(
//        private val hash: Int, // Conditionally serializable
//        private val key: K?, // Conditionally serializable
//        private val value: V?,
//    ) : LeafNode<K?, V?>(), Serializable {
//        init {
//            this.value = value
//        }
//
//        private fun equals(keyHash: Int, key: K?): Boolean {
//            return keyHash == hash && equals<K?>(key, this.key)
//        }
//
//        override fun lookup(shift: Int, keyHash: Int, key: K?): Option<V?> {
//            return Option.`when`(equals(keyHash, key), value)
//        }
//
//        override fun lookup(shift: Int, keyHash: Int, key: K?, defaultValue: V?): V? {
//            return if (equals(keyHash, key)) value else defaultValue
//        }
//
//        override fun modify(shift: Int, keyHash: Int, key: K?, value: V?, action: Action?): AbstractNode<K?, V?>? {
//            if (keyHash == hash && equals<K?>(key, this.key)) {
//                return if (action == REMOVE) EmptyNode.Companion.instance<K?, V?>() else LeafSingleton<K?, V?>(
//                    hash,
//                    key,
//                    value
//                )
//            } else {
//                return if (action == REMOVE) this else mergeLeaves<K?, V?>(
//                    shift,
//                    this,
//                    LeafSingleton<K?, V?>(keyHash, key, value)
//                )
//            }
//        }
//
//        override fun size(): Int {
//            return 1
//        }
//
//        public override fun nodes(): Iterator<LeafNode<K?, V?>?> {
//            return Iterator.of(this)
//        }
//
//        override fun hash(): Int {
//            return hash
//        }
//
//        override fun key(): K? {
//            return key
//        }
//
//        override fun value(): V? {
//            return value
//        }
//
//        companion object {
//            private const val serialVersionUID = 1L
//        }
//    }
//
//    /**
//     * Representation of a HAMT leaf node with more than one element.
//     *
//     * @param <K> Key type
//     * @param <V> Value type
//    </V></K> */
//    class LeafList<K, V> internal constructor(hash: Int, key: K?, value: V?, tail: LeafNode<K?, V?>) :
//        LeafNode<K?, V?>(), Serializable {
//        private val hash: Int
//
//        // Conditionally serializable
//        private val key: K?
//
//        // Conditionally serializable
//        private val value: V?
//        private val size: Int
//        private val tail: LeafNode<K?, V?>
//
//        init {
//            this.hash = hash
//            this.key = key
//            this.value = value
//            this.size = 1 + tail.size()
//            this.tail = tail
//        }
//
//        override fun lookup(shift: Int, keyHash: Int, key: K?): Option<V?> {
//            if (hash != keyHash) {
//                return Option.none()
//            }
//            return nodes().find({ node -> Objects.equals<T?>(node.key(), key) })
//                .map({ obj: LeafNode<*, *>? -> obj!!.value() })
//        }
//
//        override fun lookup(shift: Int, keyHash: Int, key: K?, defaultValue: V?): V? {
//            if (hash != keyHash) {
//                return defaultValue
//            }
//            var result = defaultValue
//            val iterator: Iterator<LeafNode<K?, V?>?> = nodes()
//            while (iterator.hasNext()) {
//                val node: LeafNode<K?, V?> = iterator.next()
//                if (equals<K?>(node.key(), key)) {
//                    result = node.value()
//                    break
//                }
//            }
//            return result
//        }
//
//        override fun modify(shift: Int, keyHash: Int, key: K?, value: V?, action: Action?): AbstractNode<K?, V?>? {
//            if (keyHash == hash) {
//                val filtered = removeElement(key)
//                if (action == REMOVE) {
//                    return filtered
//                } else {
//                    return HashArrayMappedTrieModule.LeafList<K?, V?>(
//                        hash,
//                        key,
//                        value,
//                        (filtered as HashArrayMappedTrieModule.LeafNode<K?, V?>?)!!
//                    )
//                }
//            } else {
//                return if (action == REMOVE) this else mergeLeaves<K?, V?>(
//                    shift,
//                    this,
//                    LeafSingleton<K?, V?>(keyHash, key, value)
//                )
//            }
//        }
//
//        private fun removeElement(k: K?): AbstractNode<K?, V?>? {
//            if (equals<K?>(k, this.key)) {
//                return tail
//            }
//            var leaf1: LeafNode<K?, V?> = LeafSingleton<K?, V?>(hash, key, value)
//            var leaf2: LeafNode<K?, V?>? = tail
//            var found = false
//            while (!found && leaf2 != null) {
//                if (equals<K?>(k, leaf2.key())) {
//                    found = true
//                } else {
//                    leaf1 = LeafList<K?, V?>(leaf2.hash(), leaf2.key(), leaf2.value(), leaf1)
//                }
//                leaf2 = if (leaf2 is LeafList<*, *>) (leaf2 as LeafList<K?, V?>).tail else null
//            }
//            return mergeNodes<K?, V?>(leaf1, leaf2)
//        }
//
//        override fun size(): Int {
//            return size
//        }
//
//        public override fun nodes(): Iterator<LeafNode<K?, V?>?> {
//            return object : AbstractIterator<LeafNode<K?, V?>?>() {
//                var node: LeafNode<K?, V?>? = this@LeafList
//
//                public override fun hasNext(): Boolean {
//                    return node != null
//                }
//
//                val next: LeafNode<K?, V?>
//                    get() {
//                        val result = node
//                        if (node is LeafSingleton<*, *>) {
//                            node = null
//                        } else {
//                            node = (node as LeafList<K?, V?>).tail
//                        }
//                        return result!!
//                    }
//            }
//        }
//
//        override fun hash(): Int {
//            return hash
//        }
//
//        override fun key(): K? {
//            return key
//        }
//
//        override fun value(): V? {
//            return value
//        }
//
//        companion object {
//            private const val serialVersionUID = 1L
//
//            private fun <K, V> mergeNodes(leaf1: LeafNode<K?, V?>, leaf2: LeafNode<K?, V?>?): AbstractNode<K?, V?>? {
//                if (leaf2 == null) {
//                    return leaf1
//                }
//                if (leaf1 is LeafSingleton<*, *>) {
//                    return LeafList<K?, V?>(leaf1.hash(), leaf1.key(), leaf1.value(), leaf2)
//                }
//                if (leaf2 is LeafSingleton<*, *>) {
//                    return LeafList<K?, V?>(leaf2.hash(), leaf2.key(), leaf2.value(), leaf1)
//                }
//                var result = leaf1
//                var tail: LeafNode<K?, V?>? = leaf2
//                while (tail is LeafList<*, *>) {
//                    val list = tail as LeafList<K?, V?>
//                    result = LeafList<K?, V?>(list.hash, list.key, list.value, result)
//                    tail = list.tail
//                }
//                return LeafList<K?, V?>(tail!!.hash(), tail.key(), tail.value(), result)
//            }
//        }
//    }
//
//    /**
//     * Representation of a HAMT indexed node.
//     *
//     * @param <K> Key type
//     * @param <V> Value type
//    </V></K> */
//    class IndexedNode<K, V> internal constructor(bitmap: Int, size: Int, subNodes: Array<Any?>) :
//        AbstractNode<K?, V?>(), Serializable {
//        private val bitmap: Int
//        private val size: Int
//
//        // Conditionally serializable
//        private val subNodes: Array<Any?>
//
//        init {
//            this.bitmap = bitmap
//            this.size = size
//            this.subNodes = subNodes
//        }
//
//        override fun lookup(shift: Int, keyHash: Int, key: K?): Option<V?>? {
//            val frag = hashFragment(shift, keyHash)
//            val bit = toBitmap(frag)
//            if ((bitmap and bit) != 0) {
//                val n = subNodes[fromBitmap(bitmap, bit)] as AbstractNode<K?, V?>
//                return n.lookup(shift + SIZE, keyHash, key)
//            } else {
//                return Option.none()
//            }
//        }
//
//        override fun lookup(shift: Int, keyHash: Int, key: K?, defaultValue: V?): V? {
//            val frag = hashFragment(shift, keyHash)
//            val bit = toBitmap(frag)
//            if ((bitmap and bit) != 0) {
//                val n = subNodes[fromBitmap(bitmap, bit)] as AbstractNode<K?, V?>
//                return n.lookup(shift + SIZE, keyHash, key, defaultValue)
//            } else {
//                return defaultValue
//            }
//        }
//
//        override fun modify(shift: Int, keyHash: Int, key: K?, value: V?, action: Action?): AbstractNode<K?, V?>? {
//            val frag = hashFragment(shift, keyHash)
//            val bit = toBitmap(frag)
//            val index = fromBitmap(bitmap, bit)
//            val mask = bitmap
//            val exists = (mask and bit) != 0
//            val atIndx: AbstractNode<K?, V?> =
//                (if (exists) subNodes[index] as HashArrayMappedTrieModule.AbstractNode<K?, V?>? else null)!!
//            val child =
//                if (exists)
//                    atIndx.modify(shift + SIZE, keyHash, key, value, action)
//                else
//                    EmptyNode.Companion.instance<K?, V?>()!!.modify(shift + SIZE, keyHash, key, value, action)
//            val removed = exists && child.isEmpty
//            val added = !exists && !child.isEmpty
//            val newBitmap = if (removed) mask and bit.inv() else if (added) mask or bit else mask
//            if (newBitmap == 0) {
//                return EmptyNode.Companion.instance<K?, V?>()
//            } else if (removed) {
//                if (subNodes.size <= 2 && subNodes[index xor 1] is LeafNode<*, *>) {
//                    return subNodes[index xor 1] as AbstractNode<K?, V?>? // collapse
//                } else {
//                    return IndexedNode<K?, V?>(newBitmap, size - atIndx.size(), remove(subNodes, index))
//                }
//            } else if (added) {
//                if (subNodes.size >= MAX_INDEX_NODE) {
//                    return expand(frag, child, mask, subNodes)
//                } else {
//                    return IndexedNode<K?, V?>(newBitmap, size + child.size(), insert(subNodes, index, child))
//                }
//            } else {
//                if (!exists) {
//                    return this
//                } else {
//                    return IndexedNode<K?, V?>(
//                        newBitmap,
//                        size - atIndx.size() + child.size(),
//                        update(subNodes, index, child)
//                    )
//                }
//            }
//        }
//
//        private fun expand(
//            frag: Int,
//            child: AbstractNode<K?, V?>,
//            mask: Int,
//            subNodes: Array<Any?>,
//        ): ArrayNode<K?, V?> {
//            var bit = mask
//            var count = 0
//            var ptr = 0
//            val arr = kotlin.arrayOfNulls<Any>(BUCKET_SIZE)
//            for (i in 0..<BUCKET_SIZE) {
//                if ((bit and 1) != 0) {
//                    arr[i] = subNodes[ptr++]
//                    count++
//                } else if (i == frag) {
//                    arr[i] = child
//                    count++
//                } else {
//                    arr[i] = EmptyNode.Companion.instance<Any?, Any?>()
//                }
//                bit = bit ushr 1
//            }
//            return ArrayNode<K?, V?>(count, size + child.size(), arr)
//        }
//
//        override fun isEmpty(): Boolean {
//            return false
//        }
//
//        override fun size(): Int {
//            return size
//        }
//
//        companion object {
//            private const val serialVersionUID = 1L
//        }
//    }
//
//    /**
//     * Representation of a HAMT array node.
//     *
//     * @param <K> Key type
//     * @param <V> Value type
//    </V></K> */
//    class ArrayNode<K, V> internal constructor(count: Int, size: Int, subNodes: Array<Any?>) : AbstractNode<K?, V?>(),
//        Serializable {
//        // Conditionally serializable
//        private val subNodes: Array<Any?>
//        private val count: Int
//        private val size: Int
//
//        init {
//            this.subNodes = subNodes
//            this.count = count
//            this.size = size
//        }
//
//        override fun lookup(shift: Int, keyHash: Int, key: K?): Option<V?>? {
//            val frag = hashFragment(shift, keyHash)
//            val child = subNodes[frag] as AbstractNode<K?, V?>
//            return child.lookup(shift + SIZE, keyHash, key)
//        }
//
//        override fun lookup(shift: Int, keyHash: Int, key: K?, defaultValue: V?): V? {
//            val frag = hashFragment(shift, keyHash)
//            val child = subNodes[frag] as AbstractNode<K?, V?>
//            return child.lookup(shift + SIZE, keyHash, key, defaultValue)
//        }
//
//        override fun modify(shift: Int, keyHash: Int, key: K?, value: V?, action: Action?): AbstractNode<K?, V?> {
//            val frag = hashFragment(shift, keyHash)
//            val child = subNodes[frag] as AbstractNode<K?, V?>
//            val newChild = child.modify(shift + SIZE, keyHash, key, value, action)
//            if (child.isEmpty && !newChild.isEmpty) {
//                return ArrayNode<K?, V?>(count + 1, size + newChild.size(), update(subNodes, frag, newChild))
//            } else if (!child.isEmpty && newChild.isEmpty) {
//                if (count - 1 <= MIN_ARRAY_NODE) {
//                    return pack(frag, subNodes)
//                } else {
//                    return ArrayNode<K?, V?>(
//                        count - 1,
//                        size - child.size(),
//                        update(subNodes, frag, EmptyNode.Companion.instance<Any?, Any?>())
//                    )
//                }
//            } else {
//                return ArrayNode<K?, V?>(count, size - child.size() + newChild.size(), update(subNodes, frag, newChild))
//            }
//        }
//
//        private fun pack(idx: Int, elements: Array<Any?>): IndexedNode<K?, V?> {
//            val arr = kotlin.arrayOfNulls<Any>(count - 1)
//            var bitmap = 0
//            var size = 0
//            var ptr = 0
//            for (i in 0..<BUCKET_SIZE) {
//                val elem = elements[i] as AbstractNode<K?, V?>
//                if (i != idx && !elem.isEmpty) {
//                    size += elem.size()
//                    arr[ptr++] = elem
//                    bitmap = bitmap or (1 shl i)
//                }
//            }
//            return IndexedNode<K?, V?>(bitmap, size, arr)
//        }
//
//        override fun isEmpty(): Boolean {
//            return false
//        }
//
//        override fun size(): Int {
//            return size
//        }
//
//        companion object {
//            private const val serialVersionUID = 1L
//        }
//    }
//}
